/*
 * Copyright 2002-2017 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.jms.connection;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.JMSContext;
import javax.jms.JMSException;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.TopicConnection;
import javax.jms.TopicConnectionFactory;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.core.NamedThreadLocal;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

/**
 * An adapter for a target JMS {@link javax.jms.ConnectionFactory}, applying the
 * given user credentials to every standard {@code createConnection()} call,
 * that is, implicitly invoking {@code createConnection(username, password)}
 * on the target. All other methods simply delegate to the corresponding methods
 * of the target ConnectionFactory.
 *
 * <p>Can be used to proxy a target JNDI ConnectionFactory that does not have user
 * credentials configured. Client code can work with the ConnectionFactory without
 * passing in username and password on every {@code createConnection()} call.
 *
 * <p>In the following example, client code can simply transparently work
 * with the preconfigured "myConnectionFactory", implicitly accessing
 * "myTargetConnectionFactory" with the specified user credentials.
 *
 * <pre class="code">
 * &lt;bean id="myTargetConnectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean"&gt;
 *   &lt;property name="jndiName" value="java:comp/env/jms/mycf"/&gt;
 * &lt;/bean&gt;
 *
 * &lt;bean id="myConnectionFactory" class="org.springframework.jms.connection.UserCredentialsConnectionFactoryAdapter"&gt;
 *   &lt;property name="targetConnectionFactory" ref="myTargetConnectionFactory"/&gt;
 *   &lt;property name="username" value="myusername"/&gt;
 *   &lt;property name="password" value="mypassword"/&gt;
 * &lt;/bean></pre>
 *
 * <p>If the "username" is empty, this proxy will simply delegate to the standard
 * {@code createConnection()} method of the target ConnectionFactory.
 * This can be used to keep a UserCredentialsConnectionFactoryAdapter bean
 * definition just for the <i>option</i> of implicitly passing in user credentials
 * if the particular target ConnectionFactory requires it.
 *
 * @author Juergen Hoeller
 * @see #createConnection
 * @see #createQueueConnection
 * @see #createTopicConnection
 * @since 1.2
 */
public class UserCredentialsConnectionFactoryAdapter
        implements ConnectionFactory, QueueConnectionFactory, TopicConnectionFactory, InitializingBean {

    private final ThreadLocal<JmsUserCredentials> threadBoundCredentials =
            new NamedThreadLocal<>("Current JMS user credentials");
    @Nullable
    private ConnectionFactory targetConnectionFactory;
    @Nullable
    private String username;
    @Nullable
    private String password;

    /**
     * Set the target ConnectionFactory that this ConnectionFactory should delegate to.
     */
    public void setTargetConnectionFactory(ConnectionFactory targetConnectionFactory) {
        Assert.notNull(targetConnectionFactory, "'targetConnectionFactory' must not be null");
        this.targetConnectionFactory = targetConnectionFactory;
    }

    /**
     * Set the username that this adapter should use for retrieving Connections.
     * Default is no specific user.
     */
    public void setUsername(String username) {
        this.username = username;
    }

    /**
     * Set the password that this adapter should use for retrieving Connections.
     * Default is no specific password.
     */
    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public void afterPropertiesSet() {
        if (this.targetConnectionFactory == null) {
            throw new IllegalArgumentException("Property 'targetConnectionFactory' is required");
        }
    }


    /**
     * Set user credententials for this proxy and the current thread.
     * The given username and password will be applied to all subsequent
     * {@code createConnection()} calls on this ConnectionFactory proxy.
     * <p>This will override any statically specified user credentials,
     * that is, values of the "username" and "password" bean properties.
     *
     * @param username the username to apply
     * @param password the password to apply
     * @see #removeCredentialsFromCurrentThread
     */
    public void setCredentialsForCurrentThread(String username, String password) {
        this.threadBoundCredentials.set(new JmsUserCredentials(username, password));
    }

    /**
     * Remove any user credentials for this proxy from the current thread.
     * Statically specified user credentials apply again afterwards.
     *
     * @see #setCredentialsForCurrentThread
     */
    public void removeCredentialsFromCurrentThread() {
        this.threadBoundCredentials.remove();
    }


    /**
     * Determine whether there are currently thread-bound credentials,
     * using them if available, falling back to the statically specified
     * username and password (i.e. values of the bean properties) else.
     *
     * @see #doCreateConnection
     */
    @Override
    public final Connection createConnection() throws JMSException {
        JmsUserCredentials threadCredentials = this.threadBoundCredentials.get();
        if (threadCredentials != null) {
            return doCreateConnection(threadCredentials.username, threadCredentials.password);
        } else {
            return doCreateConnection(this.username, this.password);
        }
    }

    /**
     * Delegate the call straight to the target ConnectionFactory.
     */
    @Override
    public Connection createConnection(String username, String password) throws JMSException {
        return doCreateConnection(username, password);
    }

    /**
     * This implementation delegates to the {@code createConnection(username, password)}
     * method of the target ConnectionFactory, passing in the specified user credentials.
     * If the specified username is empty, it will simply delegate to the standard
     * {@code createConnection()} method of the target ConnectionFactory.
     *
     * @param username the username to use
     * @param password the password to use
     * @return the Connection
     * @see javax.jms.ConnectionFactory#createConnection(String, String)
     * @see javax.jms.ConnectionFactory#createConnection()
     */
    protected Connection doCreateConnection(@Nullable String username, @Nullable String password) throws JMSException {
        ConnectionFactory target = obtainTargetConnectionFactory();
        if (StringUtils.hasLength(username)) {
            return target.createConnection(username, password);
        } else {
            return target.createConnection();
        }
    }

    /**
     * Determine whether there are currently thread-bound credentials,
     * using them if available, falling back to the statically specified
     * username and password (i.e. values of the bean properties) else.
     *
     * @see #doCreateQueueConnection
     */
    @Override
    public final QueueConnection createQueueConnection() throws JMSException {
        JmsUserCredentials threadCredentials = this.threadBoundCredentials.get();
        if (threadCredentials != null) {
            return doCreateQueueConnection(threadCredentials.username, threadCredentials.password);
        } else {
            return doCreateQueueConnection(this.username, this.password);
        }
    }

    /**
     * Delegate the call straight to the target QueueConnectionFactory.
     */
    @Override
    public QueueConnection createQueueConnection(String username, String password) throws JMSException {
        return doCreateQueueConnection(username, password);
    }

    /**
     * This implementation delegates to the {@code createQueueConnection(username, password)}
     * method of the target QueueConnectionFactory, passing in the specified user credentials.
     * If the specified username is empty, it will simply delegate to the standard
     * {@code createQueueConnection()} method of the target ConnectionFactory.
     *
     * @param username the username to use
     * @param password the password to use
     * @return the Connection
     * @see javax.jms.QueueConnectionFactory#createQueueConnection(String, String)
     * @see javax.jms.QueueConnectionFactory#createQueueConnection()
     */
    protected QueueConnection doCreateQueueConnection(
            @Nullable String username, @Nullable String password) throws JMSException {

        ConnectionFactory target = obtainTargetConnectionFactory();
        if (!(target instanceof QueueConnectionFactory)) {
            throw new javax.jms.IllegalStateException("'targetConnectionFactory' is not a QueueConnectionFactory");
        }
        QueueConnectionFactory queueFactory = (QueueConnectionFactory) target;
        if (StringUtils.hasLength(username)) {
            return queueFactory.createQueueConnection(username, password);
        } else {
            return queueFactory.createQueueConnection();
        }
    }

    /**
     * Determine whether there are currently thread-bound credentials,
     * using them if available, falling back to the statically specified
     * username and password (i.e. values of the bean properties) else.
     *
     * @see #doCreateTopicConnection
     */
    @Override
    public final TopicConnection createTopicConnection() throws JMSException {
        JmsUserCredentials threadCredentials = this.threadBoundCredentials.get();
        if (threadCredentials != null) {
            return doCreateTopicConnection(threadCredentials.username, threadCredentials.password);
        } else {
            return doCreateTopicConnection(this.username, this.password);
        }
    }

    /**
     * Delegate the call straight to the target TopicConnectionFactory.
     */
    @Override
    public TopicConnection createTopicConnection(String username, String password) throws JMSException {
        return doCreateTopicConnection(username, password);
    }

    /**
     * This implementation delegates to the {@code createTopicConnection(username, password)}
     * method of the target TopicConnectionFactory, passing in the specified user credentials.
     * If the specified username is empty, it will simply delegate to the standard
     * {@code createTopicConnection()} method of the target ConnectionFactory.
     *
     * @param username the username to use
     * @param password the password to use
     * @return the Connection
     * @see javax.jms.TopicConnectionFactory#createTopicConnection(String, String)
     * @see javax.jms.TopicConnectionFactory#createTopicConnection()
     */
    protected TopicConnection doCreateTopicConnection(
            @Nullable String username, @Nullable String password) throws JMSException {

        ConnectionFactory target = obtainTargetConnectionFactory();
        if (!(target instanceof TopicConnectionFactory)) {
            throw new javax.jms.IllegalStateException("'targetConnectionFactory' is not a TopicConnectionFactory");
        }
        TopicConnectionFactory queueFactory = (TopicConnectionFactory) target;
        if (StringUtils.hasLength(username)) {
            return queueFactory.createTopicConnection(username, password);
        } else {
            return queueFactory.createTopicConnection();
        }
    }

    @Override
    public JMSContext createContext() {
        return obtainTargetConnectionFactory().createContext();
    }

    @Override
    public JMSContext createContext(String userName, String password) {
        return obtainTargetConnectionFactory().createContext(userName, password);
    }

    @Override
    public JMSContext createContext(String userName, String password, int sessionMode) {
        return obtainTargetConnectionFactory().createContext(userName, password, sessionMode);
    }

    @Override
    public JMSContext createContext(int sessionMode) {
        return obtainTargetConnectionFactory().createContext(sessionMode);
    }

    private ConnectionFactory obtainTargetConnectionFactory() {
        Assert.state(this.targetConnectionFactory != null, "'targetConnectionFactory' is required");
        return this.targetConnectionFactory;
    }


    /**
     * Inner class used as ThreadLocal value.
     */
    private static class JmsUserCredentials {

        public final String username;

        public final String password;

        private JmsUserCredentials(String username, String password) {
            this.username = username;
            this.password = password;
        }

        @Override
        public String toString() {
            return "JmsUserCredentials[username='" + this.username + "',password='" + this.password + "']";
        }
    }

}
